home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1995 March / macformat-022.iso / Shareware City / Science / µSim 1.0b5 folder / source / InitMenus.c < prev    next >
Encoding:
Text File  |  1994-10-03  |  26.3 KB  |  934 lines  |  [TEXT/MMCC]
  1. /*
  2. Copyright © 1993,1994 by Fabrizio Oddone
  3. ••• ••• ••• ••• ••• ••• ••• ••• ••• •••
  4. This source code is distributed as freeware: you can copy, exchange, modify this
  5. code as you wish. You may include this code in any kind of application: freeware,
  6. shareware, or commercial, provided that full credits are given.
  7. You may not sell or distribute this code for profit.
  8. */
  9.  
  10. //#pragma load "MacDump"
  11.  
  12. #include    "UtilsSys7.h"
  13. #include    "Globals.h"
  14. #include    "AEHandlers.h"
  15. #include    "Animation.h"
  16. #include    "ControlStore.h"
  17. #include    "CursorBalloon.h"
  18. #include    "Disasm.h"
  19. #include    "DoEditDialog.h"
  20. #include    "DoMenu.h"
  21. #include    "Dump.h"
  22. #include    "InitCursorBalloon.h"
  23. #include    "InitMenus.h"
  24. #include    "Input.h"
  25. #include    "Main.h"
  26. #include    "Microprogram_Ed.h"
  27. #include    "Registers.h"
  28. #include    "SimAsm.h"
  29. #include    "SimUtils.h"
  30. #include    "Independents.h"
  31.  
  32. #if defined(FabSystem7orlater)
  33.  
  34. #pragma segment __%Main
  35.  
  36. static AEEventHandlerUPP    gmyHandleIO_UPP, gmyHandleGenericAlert_UPP;
  37.  
  38. #pragma segment Init
  39.  
  40. enum {
  41. kREGFONT = 128
  42. };
  43.  
  44. enum winds {
  45. kWIND_Microprogram_Ed = 256,
  46. kWIND_Animation,
  47. kWIND_IO,
  48. kWIND_Registers,
  49. kWIND_Dump,
  50. kWIND_Disasm
  51. };
  52.  
  53. static void Init_My_Menus(void);
  54. static void GestaltCheck(void);
  55. static OSErr Init_Microprogram_Ed(void);
  56. static OSErr Init_Animation(void);
  57. static OSErr Init_Registers(void);
  58. static OSErr Init_Disasm(void);
  59. static Boolean InitPrefs(void);
  60. static Boolean    GetFontNumber(ConstStr255Param fontName, short *fontNum);
  61. static ListHandle MakeList(RectPtr theListRect, WindowPtr theWindow, short lines);
  62. static TEHandle MakeTE(RectPtr Position);
  63. static OSErr InitIO(void);
  64. static OSErr InitDump(void);
  65. static void FatalErrorAlert(short alertID, OSErr reason);
  66.  
  67. /* Init_My_Menus: sets up the menu bar */
  68.  
  69. static void Init_My_Menus(void)
  70. {
  71.     {
  72.     register Handle menuBar;
  73.     
  74.     SetMenuBar(menuBar = GetNewMBar(kRes_Menu_Apple));
  75.     DisposHandle(menuBar);
  76.     }
  77.  
  78. AddResMenu(gMenu_Apple = GetMHandle(kRes_Menu_Apple),'DRVR');
  79. gMenu_File = GetMHandle(kRes_Menu_File);
  80. gMenu_Edit = GetMHandle(kRes_Menu_Edit);
  81. gMenu_Windows = GetMHandle(kRes_Menu_Windows);
  82. gMenu_Control = GetMHandle(kRes_Menu_Control);
  83. gMenu_Assembler = GetMHandle(kRes_Menu_Assembler);
  84. InsertMenu(gMenu_Memory = GetMenu(kRes_Menu_HMemory), hierMenu);
  85. InsertMenu(gMenu_Registers = GetMenu(kRes_Menu_HRegs), hierMenu);
  86. InsertMenu(gMenu_DisasmF = GetMenu(kRes_Menu_HDisasm), hierMenu);
  87. InsertMenu(gMenu_DumpF = GetMenu(kRes_Menu_HDump), hierMenu);
  88. gPopMenu = GetMenu(kRes_Menu_PopDump);
  89. DrawMenuBar();
  90. }
  91.  
  92. /* InitAll: initializes the whole environment */
  93.  
  94. void InitAll(void)
  95. {
  96. long    timingInfo;
  97. Rect    startingRect, endingRect;
  98. Point    dummyPt = {0, 0};
  99. DialogPtr    agh;
  100. register Handle    splash;
  101. register OSErr    err;
  102. register Boolean    prefsFileWasAbsent;
  103.  
  104. timingInfo = TickCount();
  105.  
  106. gMyGrowZoneUPP = NewGrowZoneProc(MyGrowZone);
  107. SetGrowZone(gMyGrowZoneUPP);
  108. MoreMasters();
  109. MoreMasters();
  110. MoreMasters();
  111. MoreMasters();
  112. MoreMasters();
  113. MoreMasters();
  114. InitGraf(&qd.thePort);
  115. InitFonts();
  116. InitWindows();
  117. InitMenus();
  118. TEInit();
  119. InitDialogs(nil);
  120.  
  121. FlushEvents(everyEvent, 0);
  122. InitCursor();
  123.  
  124. (void)UnloadScrap();
  125.  
  126. GestaltCheck();
  127.  
  128. gWatchHandle = GetCursor(watchCursor);
  129. SetCursor(*gWatchHandle);
  130.  
  131. gmyCallbackUPP = NewSndCallBackProc(myCallback);
  132.  
  133. gInstrClikLoopUPP = MyNewListClickLoopProc(instrClikLoop);
  134. gCommentClikLoopUPP = MyNewListClickLoopProc(commentClikLoop);
  135. gSwitchCursClikLoopUPP = MyNewListClickLoopProc(switchCursClikLoop);
  136.  
  137. (void)InitCursorBalloonManager();
  138.  
  139. splash = OpenSplash(&agh, nil);
  140. SetPort(agh);
  141. endingRect = agh->portRect;
  142. LocalToGlobal(&topLeft(endingRect));
  143. LocalToGlobal(&botRight(endingRect));
  144. startingRect = endingRect;
  145. InsetRect(&startingRect, ((endingRect.right - endingRect.left) >> 1) - 2,
  146.             ((endingRect.bottom - endingRect.top) >> 1) - 2);
  147.  
  148. timingInfo = TickCount() - timingInfo;
  149. if (timingInfo >= 28)    /* unusually slow machine */
  150.     gZoomFactor = 4;
  151. else if (timingInfo >= 17)    /* Plus, SE, Classic Mac */
  152.     gZoomFactor = 5;
  153. else if (timingInfo >= 10)
  154.     gZoomFactor = 6;
  155. else if (timingInfo >= 4)    /* Quadra class Mac */
  156.     gZoomFactor = 7;
  157. else if (timingInfo >= 2)
  158.     gZoomFactor = 8;
  159. else    /* super-duper (RISC?) Macintosh */
  160.     gZoomFactor = 9;
  161.  
  162. ZoomRectToRectAutoGrafPort(&startingRect, &endingRect, gZoomFactor);
  163. ShowWindow(agh);
  164. DrawDialog(agh);
  165.  
  166. gIBeamHandle = GetCursor(iBeamCursor);
  167. gPlusHandle = GetCursor(plusCursor);
  168.  
  169. gMMemory = NewPtrClear(kSIZE_RAM);
  170. gCsMemory = (union u_mir *)NewPtrClear(kSIZE_ASSMEM + kSIZE_CSMEM);
  171. if (gCsMemory)
  172.     gAssMemory = (((Ptr)gCsMemory) + kSIZE_CSMEM);
  173.  
  174. MyFillBuffer((long *)gAssMemory, numOfLongs(kSIZE_ASSMEM), 0x03030303);
  175. Init_My_Menus();
  176.  
  177. gRegs[kREG_ZERO] = 0;
  178. gRegs[kREG_ONE] = 1;
  179. gRegs[kREG_MINUS1] = -1;
  180.  
  181. prefsFileWasAbsent = InitPrefs();
  182. ResetMemory();
  183. ResetRegisters();
  184. UnloadSeg(ResetRegisters);
  185. if (Init_Animation()) ExitToShell();
  186. if (Init_Microprogram_Ed()) ExitToShell();
  187. if (Init_Registers()) ExitToShell();
  188. if (InitIO()) ExitToShell();
  189. if (InitDump()) ExitToShell();
  190. if (Init_Disasm()) ExitToShell();
  191. SetMir(-1L);
  192. SetMir(0L);
  193.  
  194. if (prefsFileWasAbsent)
  195.     gPrefs.remembWind = true;
  196.  
  197. if(err = InstallRequiredAEHandlers(myHandleOAPP, myHandleODOC, myHandlePDOC, myHandleQUIT)) {
  198.     FatalErrorAlert(kALRT_ERROR, err);
  199.     gDoneFlag = true;
  200.     }
  201.  
  202. gmyHandleIO_UPP = NewAEEventHandlerProc(myHandleIO);
  203. gmyHandleGenericAlert_UPP = NewAEEventHandlerProc(myHandleGenericAlert);
  204. if(err = AEInstallEventHandler(kFCR_MINE, kAEmySignalIO, gmyHandleIO_UPP, 0, false)) {
  205.     FatalErrorAlert(kALRT_ERROR, err);
  206.     gDoneFlag = true;
  207.     }
  208.  
  209. if(err = AEInstallEventHandler(kCreat, kAEAlert, gmyHandleGenericAlert_UPP, 0, false)) {
  210.     FatalErrorAlert(kALRT_ERROR, err);
  211.     gDoneFlag = true;
  212.     }
  213.  
  214. (void)TEFromScrap();
  215.  
  216. DisposeSplash(splash, agh);
  217. UnloadSeg(DisposeSplash);
  218.  
  219. if (gPrefs.AnimVisible)
  220.     ShowWindowAndCheckMenu(gWPtr_Animation, kMItem_Animation);
  221. if (gPrefs.DisasmVisible) {
  222.     DecideActivation(gWPtr_Disasm, dummyPt, false);
  223.     ShowWindowAndCheckMenu(gWPtr_Disasm, kMItem_Disasm);
  224.     }
  225. if (gPrefs.DumpVisible) {
  226.     DecideActivation(gWPtr_Dump, dummyPt, false);
  227.     ShowWindowAndCheckMenu(gWPtr_Dump, kMItem_Dump);
  228.     }
  229. if (gPrefs.IOVisible) {
  230.     DecideActivation(gWPtr_IO, dummyPt, false);
  231.     ShowWindowAndCheckMenu(gWPtr_IO, kMItem_IO);
  232.     }
  233. if (gPrefs.RegsVisible)
  234.     ShowWindowAndCheckMenu(gWPtr_Registers, kMItem_Registers);
  235.  
  236. gILCBase = gRegs[kREG_PC];
  237.  
  238. InitCursor();
  239. }
  240.  
  241. /* GestaltCheck: is this Mac set up with all we need to run? */
  242.  
  243. static void GestaltCheck(void)
  244. {
  245. #define    POWERMANAGER    ((1L << gestaltPMgrExists)|(1L << gestaltPMgrCPUIdle))
  246. #define TEMPMEMMANAGER    ((1L << gestaltTempMemSupport)|(1L << gestaltRealTempMemory)|(1L << gestaltTempMemTracked))
  247. long    Gresp;
  248.  
  249. gHasColorQD = false;
  250. gPwrManagerIsPresent = false;
  251. if (TrapAvailable(_Gestalt)) {
  252.     if (Gestalt(gestaltQuickdrawVersion, &Gresp) == noErr)
  253.         gHasColorQD = ((Byte)(Gresp >> 8)) > 0;
  254.     if (Gestalt(gestaltPowerMgrAttr, &Gresp) == noErr)
  255.         gPwrManagerIsPresent = ((Gresp & POWERMANAGER) == POWERMANAGER) != 0;
  256.     if (Gestalt(gestaltAliasMgrAttr, &Gresp) == noErr)
  257.         if (Gresp & (1L << gestaltAliasMgrPresent))
  258.             if (Gestalt(gestaltAppleEventsAttr, &Gresp) == noErr)
  259.                 if (Gresp & (1L << gestaltAppleEventsPresent))
  260.                     if (Gestalt(gestaltDITLExtAttr, &Gresp) == noErr)
  261.                         if (Gresp & (1L << gestaltDITLExtPresent))
  262.                             if (Gestalt(gestaltFindFolderAttr, &Gresp) == noErr)
  263.                                 if (Gresp & (1L << gestaltFindFolderPresent))
  264.                             if (Gestalt(gestaltFSAttr, &Gresp) == noErr)
  265.                                 if (Gresp & (1L << gestaltHasFSSpecCalls))
  266.                             if (Gestalt(gestaltHelpMgrAttr, &Gresp) == noErr)
  267.                                 if (Gresp & (1L << gestaltHelpMgrPresent))
  268.                             if (Gestalt(gestaltPopupAttr, &Gresp) == noErr)
  269.                                 if (Gresp & (1L << gestaltPopupPresent))
  270.                     //        if (Gestalt(gestaltResourceMgrAttr, &Gresp) == noErr)
  271.                     //            if (Gresp & (1L << gestaltPartialRsrcs))
  272.                             if (Gestalt(gestaltStandardFileAttr, &Gresp) == noErr)
  273.                                 if (Gresp & (1L << gestaltStandardFile58))
  274.                             if (Gestalt(gestaltTextEditVersion, &Gresp) == noErr)
  275.                                 if (Gresp >= gestaltTE4)
  276.                             if (Gestalt(gestaltOSAttr, &Gresp) == noErr)
  277.                                 if ((Gresp & TEMPMEMMANAGER) == TEMPMEMMANAGER)
  278.                             /* proceed because everything is OK */
  279.                                 return;
  280.     }
  281. (void)StopAlert(kALRT_NOSYS7, nil);
  282. ExitToShell();
  283. }
  284.  
  285. /* Init_Microprogram_Ed: initializes the Microprogram window */
  286.  
  287. static OSErr Init_Microprogram_Ed(void)
  288. {
  289. enum {
  290. kR_RECTS = 128
  291. };
  292.  
  293. register Handle    tempSH;
  294. register ControlHandle *ControlScan;
  295. register RgnHandle    theRgn;
  296. register WindowPtr    w;
  297. Rect    tempRect;
  298. Point tempCell;
  299. register short i;
  300. register OSErr    err = appMemFullErr;
  301.  
  302. tempCell.h = 0;
  303.     {
  304.     register RectPtr    RectScan, *keyRScan;
  305.     register short    numrects;
  306.     short *numrectsPtr;
  307.  
  308.     RectScan = (RectPtr)((numrectsPtr = (short *)*Get1Resource('nrct', kR_RECTS)) + 1);
  309.     for (numrects = *numrectsPtr, keyRScan = keyrects, i = 0; i < numrects; i++)
  310.         *keyRScan++ = RectScan++;
  311.     }
  312. maxLLine[kL_COMMENTS] = 127;
  313. tempSH = Get1Resource(krInstructions, kOPCODES);
  314. maxLLine[kL_INSTR] = *(unsigned short *)*tempSH;
  315. gWPtr_Microprogram_Ed = w = GetNewWindow(kWIND_Microprogram_Ed, NewPtrClear(sizeof(FabWindowRecord)), (WindowPtr)-1L);
  316. if (w) {
  317.     SetPort(w);
  318.     if (gPrefs.remembWind)
  319.         if (PtInRgn(gPrefs.MProgTopLeft, GetGrayRgn()))
  320.             MoveWindow(w, gPrefs.MProgTopLeft.h, gPrefs.MProgTopLeft.v, false);
  321.     TextFont(geneva);
  322.     TextSize(9);
  323.     for( ControlScan = &controls[kNUM_CONTROLS], i = kRES_CNTL+kNUM_CONTROLS-1;
  324.         i >= kRES_CNTL; i-- )
  325.         *--ControlScan = GetNewControl(i, w);
  326.     Lists[kL_COMMENTS] = MakeList(keyrects[kKEY_LIST], w,
  327.                                     maxLLine[kL_COMMENTS]+1);
  328.     (*Lists[kL_COMMENTS])->lClickLoop = gCommentClikLoopUPP;
  329.     Lists[kL_INSTR] = MakeList(keyrects[kKEY_INSTR], w,
  330.                                 maxLLine[kL_INSTR]+1);
  331.     (*Lists[kL_INSTR])->lClickLoop = gInstrClikLoopUPP;
  332.     TextFont(systemFont);
  333.     TextSize(12);
  334.     TEs[kKEY_COMMENT] = MakeTE(keyrects[kKEY_COMMENT]);
  335.     (void)TEFeatureFlag(teFOutlineHilite, TEBitSet, TEs[kKEY_COMMENT]);
  336.     TEs[kKEY_BRTO] = MakeTE(keyrects[kKEY_BRTO]);
  337.     (void)TEFeatureFlag(teFOutlineHilite, TEBitSet, TEs[kKEY_BRTO]);
  338.     TextFont(geneva);
  339.     TextSize(9);
  340.         {
  341.         register ROpcodePtr    instrScan;
  342.         register SignedByte    savedState;
  343.     
  344.         savedState = WantThisHandleSafe(tempSH);
  345.         instrScan = (ROpcodePtr)(((short *)(*tempSH))+1);
  346.         for ( i = 0; i <= maxLLine[kL_INSTR]; i++, instrScan++) {
  347.             tempCell.v = i;
  348.             LSetCell(instrScan, 4, tempCell, Lists[kL_INSTR]);
  349.             }
  350.         HSetState(tempSH, savedState);
  351.         }
  352.     ResetMicroprogramWindow();
  353.     UnloadSeg(ResetMicroprogramWindow);
  354.  
  355.     InitFabWindow(w);
  356.     SetActivate(w, Activate_Microprogram_Ed);
  357.     SetUpdate(w, Update_Microprogram_Ed);
  358.     SetDrag(w, nil);
  359.     SetGrow(w, nil);
  360.     SetZoom(w, nil);
  361.     SetGoAway(w, CloseMicroProg);
  362.     SetContent(w, Do_Microprogram_Ed);
  363.  
  364.     for (i = kKEY_BRTO; i <= kKEY_INSTR; i++) {
  365.         theRgn = NewRgn();
  366.         tempRect = *keyrects[i];
  367.         if (i > kKEY_COMMENT)
  368.             tempRect.right -= kScrollbarAdjust;
  369.         RectRgn(theRgn, &tempRect);
  370.         InstallRgnHandler((FabWindowPtr)w, theRgn, nil, i <= kKEY_COMMENT ? gIBeamHandle : gPlusHandle,
  371.                     toMenu(kBalloons_MPrg, i + kNUM_CONTROLS + 1), 0);
  372.         }
  373.  
  374.     for (i = kPOPUP_ABUS; i <= kCHECK_ACTMAP; i++) {
  375.         theRgn = NewRgn();
  376.         RectRgn(theRgn, &(*controls[i])->contrlRect);
  377.         InstallRgnHandler((FabWindowPtr)w, theRgn, nil, nil,
  378.                     toMenu(kBalloons_MPrg, i + 1), 0);
  379.         }
  380.  
  381. //    ResizeObjects(w);
  382.  
  383.     RecalcGlobalCoords((FabWindowPtr)w);
  384.  
  385.     err = noErr;
  386.     }
  387. return err;
  388. }
  389.  
  390. /* Init_Animation: initializes the Animation Window */
  391.  
  392. /* da schiaffare dentro la routine successiva */
  393. const short    initial[] = { kP_REGISTERS, kC_ALU2MSL1, kC_ALU2MSL2, kP_MIR, kP_TEXT, 0 };
  394.  
  395. static OSErr Init_Animation(void)
  396. {
  397. Rect    tempRect;
  398. BitMap    offBits;
  399. register WindowPtr    w;
  400. register PicHandle    tempPH;
  401. register RgnHandle    theRgn;
  402. register long    rightLong;
  403. register short    count, i;
  404. register OSErr    err = appMemFullErr;
  405.  
  406. gWPtr_Animation = w = GetNewWindow(kWIND_Animation, NewPtrClear(sizeof(FabWindowRecord)), (WindowPtr)-1L);
  407. if (w) {
  408.     SetPort(w);
  409.     if (gPrefs.remembWind)
  410.         if (PtInRgn(gPrefs.AnimTopLeft, GetGrayRgn()))
  411.             MoveWindow(w, gPrefs.AnimTopLeft.h, gPrefs.AnimTopLeft.v, false);
  412.     ClipRect(&w->portRect);
  413.     offBits.bounds = w->portRect;
  414.     rightLong = ((offBits.bounds.right + 15) >> 4) << 1;
  415.     offBits.rowBytes = rightLong;
  416.     if (offScr = (GrafPtr)NewPtrClear(sizeof(GrafPort))) {
  417.         OpenPort(offScr);
  418.         if (offBits.baseAddr = NewPtrClear(rightLong * offBits.bounds.bottom)) {
  419.             SetPortBits(&offBits);
  420.             TextFont(monaco);
  421.             ClipRect(&offBits.bounds);
  422.             PenPat(&qd.gray);
  423.             PenMode(notPatBic);
  424.             mirUpdRgn = NewRgn();
  425.                 {
  426.                 register RgnHandle tempRgn = NewRgn();
  427.                 register PicHandle *PictScan;
  428.                 register RectPtr    RectScan;
  429.             
  430.                 for(RectScan = rval, PictScan = images, count = kFIRST_PICT;
  431.                     count <= kLAST_PICT; count++) {
  432.                     register PicHandle tempPicH;
  433.                     
  434.                     tempPicH = GetPicture(count);
  435.                     *PictScan++ = tempPicH;
  436.                     tempRect = (*tempPicH)->picFrame;
  437.                     DrawPicture(tempPicH, &tempRect);
  438.                     RectRgn(tempRgn, &tempRect);
  439.                     PaintRgn(tempRgn);
  440.                     if( count <= kP_MPC ) {
  441.                         --tempRect.bottom;
  442.                         --tempRect.right;
  443.                         InsetRect(&tempRect, 3, 3);
  444.                         *RectScan++ = tempRect;
  445.                         }
  446.                     else if( count == kP_ALU ) {
  447.                         tempRect.bottom -= 4;
  448.                         tempRect.right -= 15;
  449.                         tempRect.left += 15;
  450.                         tempRect.top = tempRect.bottom - 15;
  451.                         *RectScan++ = tempRect;
  452.                         }
  453.                     else if( count == kP_MSL ) {
  454.                         tempRect.bottom -= 3;
  455.                         tempRect.top += 3;
  456.                         tempRect.right -= 3;
  457.                         tempRect.left += 19;
  458.                         *RectScan++ = tempRect;
  459.                         }
  460.                     else if( count == kP_MIR ) {
  461.                         register short    i;
  462.             
  463.                         tempRect.bottom -= 2;
  464.                         ++tempRect.left;
  465.                         tempRect.top = tempRect.bottom - 15;
  466.                         tempRect.right = tempRect.left + 11;
  467.                         for( i = 0; i <= 12; i++) {
  468.                             *RectScan++ = tempRect;
  469.                             RectRgn(tempRgn, &tempRect);
  470.                             UnionRgn(mirUpdRgn, tempRgn, mirUpdRgn);
  471.                             tempRect.left += 12;
  472.                             tempRect.right += 12;
  473.                             }
  474.                         tempRect.right += 11;
  475.                         *RectScan = tempRect;
  476.                         RectRgn(tempRgn, &tempRect);
  477.                         UnionRgn(mirUpdRgn, tempRgn, mirUpdRgn);
  478.                         }
  479.                     }
  480.                 DisposeRgn(tempRgn);
  481.                 }
  482.             ChangedAllBoxes();
  483.             ActivateObjs(initial);
  484.  
  485.             InitFabWindow(w);
  486.             SetActivate(w, nil);
  487.             SetUpdate(w, Update_Animation);
  488.             SetDrag(w, nil);
  489.             SetGrow(w, nil);
  490.             SetZoom(w, nil);
  491.             SetGoAway(w, CloseAnimation);
  492.             SetContent(w, Do_Animation);
  493.  
  494.             for (i = kP_ALATCH - kFIRST_PICT; i <= kP_MAP - kFIRST_PICT; i++) {
  495.                 theRgn = NewRgn();
  496.                 tempPH = images[i];
  497.                 if (*tempPH == nil)
  498.                     LoadResource((Handle)tempPH);
  499.                 tempRect = (*tempPH)->picFrame;
  500.                 RectRgn(theRgn, &tempRect);
  501.                 InstallRgnHandler((FabWindowPtr)w, theRgn, nil, nil,
  502.                             toMenu(kBalloons_Anim, i + 1), 6);
  503.                 }
  504.         
  505.         //    ResizeObjects(w);
  506.         
  507.             RecalcGlobalCoords((FabWindowPtr)w);
  508.  
  509.             err = noErr;
  510.             }
  511.         }
  512.     }
  513. return err;
  514. }
  515.  
  516. /* Init_Registers: initializes the Registers window */
  517.  
  518. static OSErr Init_Registers(void)
  519. {
  520. enum {
  521. kCNTL_BASE = 129
  522. };
  523.  
  524. Str255    tempS;
  525. FMetricRec    theMetrics;
  526. Rect    tempRect;
  527. register WindowPtr    w;
  528. register Handle    myStrHandle;
  529. register RgnHandle    theRgn;
  530. register Fixed    tempFixed;
  531. short    fontNumber, fontSize;
  532. register short    theWidth, i;
  533. register short    maxLength = 0;
  534. register OSErr    err = appMemFullErr;
  535.  
  536. gWPtr_Registers = w = GetNewWindow(kWIND_Registers, NewPtrClear(sizeof(FabWindowRecord)), (WindowPtr)-1L);
  537. if (w) {
  538.     SetPort(w);
  539.     if (gPrefs.remembWind)
  540.         if (PtInRgn(gPrefs.RegsTopLeft, GetGrayRgn()))
  541.             MoveWindow(w, gPrefs.RegsTopLeft.h, gPrefs.RegsTopLeft.v, false);
  542.     (void)WantThisHandleSafe(myStrHandle = Get1Resource('REGF', kREGFONT));
  543.     if (GetFontNumber((StringPtr)(*myStrHandle + 2), &fontNumber))
  544.         fontSize = *(short *)*myStrHandle;
  545.     else {
  546.         fontNumber = monaco;
  547.         fontSize = 9;
  548.         }
  549.     ReleaseResource(myStrHandle);
  550.     TextFont(fontNumber);
  551.     TextSize(fontSize);
  552.     if (Ctrl_Base = GetNewControl(kCNTL_BASE, w)) {
  553.         FontMetrics(&theMetrics);
  554.         tempFixed = theMetrics.descent + theMetrics.ascent + theMetrics.leading;
  555.  
  556.         tempFixed = mySwap(tempFixed);
  557.  
  558.         regLineHeight = (short)tempFixed;
  559.         
  560.         regDistFromTop = *(short *)&theMetrics.ascent + kREG_HORZSEPLINE;
  561.         HLock(myStrHandle = Get1Resource('STR#', kREG_NAMES));
  562.         for(i = 0; i < kDISP_REGS; i++) {
  563.             if (maxLength < (theWidth = StringWidth(GetPtrIndHString(myStrHandle, i))))
  564.                 maxLength = theWidth;
  565.             }
  566.         HUnlock(myStrHandle);
  567.         tempFixed = maxLength;
  568.         regVertSepLine = maxLength + kDIST_FROMLEFT + kDIST_FROMNAME;
  569.         
  570.         tempFixed = mySwap(tempFixed);
  571.         
  572.         maxLength = 0;
  573.             {
  574.             register Byte *myString;
  575.             register Byte    j, rememberedCh, stopAt;
  576.             SignedByte    savedState;
  577.         
  578.             savedState = WantThisHandleSafe(myStrHandle = (Handle)GetString(kSTR_BINALLOWED));
  579.             myString = (Byte *)*myStrHandle;
  580.             for (stopAt = *myString++, j = 0; j < stopAt; j++)
  581.                 if (maxLength < (theWidth = CharWidth(*myString++))) {
  582.                     maxLength = theWidth;
  583.                     rememberedCh = *(myString - 1);
  584.                     }
  585.             HSetState(myStrHandle, savedState);
  586.             for (myString = (Byte *)&tempS, j = 0; j <= 15; j++)
  587.                 *myString++ = rememberedCh;
  588.             maxLength = TextWidth(&tempS, 0, 16);
  589.             }
  590.         
  591.         tempFixed += ((long)maxLength << 16) +
  592.             ((const long)(kDIST_FROMLEFT + kDIST_FROMNAME + kDIST_FROMVERTSEP)<< 16);
  593.         tempFixed = mySwap(tempFixed);
  594.         SizeWindow(w, (short)tempFixed + 2,
  595.                     REG_TOP + regLineHeight * kDISP_REGS, false);
  596.         SetCtlValue(Ctrl_Base, gPrefs.remembWind ? gPrefs.RegsBase : kPOP_HEX);
  597.         oldChoice = GetCtlValue(Ctrl_Base);
  598.  
  599.         InitFabWindow(w);
  600.         SetActivate(w, nil);
  601.         SetUpdate(w, Update_Registers);
  602.         SetDrag(w, nil);
  603.         SetGrow(w, nil);
  604.         SetZoom(w, nil);
  605.         SetGoAway(w, CloseRegisters);
  606.         SetContent(w, Do_Registers);
  607.  
  608.         theRgn = NewRgn();
  609.         tempRect = (*Ctrl_Base)->contrlRect;
  610.         RectRgn(theRgn, &tempRect);
  611.         InstallRgnHandler((FabWindowPtr)w, theRgn, nil, nil,
  612.                         toMenu(kBalloons_Regs, kBRegs_Base), 0);
  613.  
  614.         tempRect.top = REG_TOP;
  615.         tempRect.left = PRCT_L(w);
  616.         tempRect.bottom = REG_TOP + regLineHeight;
  617.         tempRect.right = PRCT_R(w);
  618.         for (i = kBRegs_PC; i <= kBRegs_Lo8; i++) {
  619.             theRgn = NewRgn();
  620.             RectRgn(theRgn, &tempRect);
  621.             InstallRgnHandler((FabWindowPtr)w, theRgn, nil, nil,
  622.                             toMenu(kBalloons_Regs, i), 0);
  623.             tempRect.top = tempRect.bottom;
  624.             tempRect.bottom += regLineHeight;
  625.             }
  626.  
  627.     //    ResizeObjects(w);
  628.     
  629.         RecalcGlobalCoords((FabWindowPtr)w);
  630.  
  631.         err = noErr;
  632.         }
  633.     }
  634. //SetFractEnable(false);
  635. return err;
  636. }
  637.  
  638. /* Init_Disasm: initializes the Disassembler window */
  639.  
  640. static OSErr Init_Disasm(void)
  641. {
  642. enum {
  643. rdisasmVScroll = 145
  644. };
  645.  
  646. FMetricRec    theMetrics;
  647. register Fixed    tempFix;
  648. register WindowPtr    window;
  649. register OSErr    err = appMemFullErr;
  650.  
  651. gWPtr_Disasm = window = GetNewWindow(kWIND_Disasm, NewPtrClear(sizeof(FabWindowRecord)), (WindowPtr)-1L);
  652. if (window) {
  653.     SetPort(window);
  654.     if (gPrefs.remembWind)
  655.         if (PtInRgn(gPrefs.DisasmTopLeft, GetGrayRgn()))
  656.             MoveWindow(window, gPrefs.DisasmTopLeft.h, gPrefs.DisasmTopLeft.v, false);
  657.     if (disasmVScroll = GetNewControl(rdisasmVScroll, window)) {
  658.         TextFont(monaco);
  659.         TextSize(9);
  660.         TextMode(srcCopy);
  661.         FontMetrics(&theMetrics);
  662.         tempFix = theMetrics.descent + theMetrics.ascent + theMetrics.leading;
  663.         tempFix = mySwap(tempFix);
  664.         disasmLineHeight = (short)tempFix;
  665.         disasmFromTop = *(short *)&theMetrics.ascent;
  666.         disasmCWidMax = *(short *)&theMetrics.widMax;
  667.         tempFix = FixMul(theMetrics.widMax, kMaxCharsInOneDisasmLineFixed);
  668.         tempFix = mySwap(tempFix);
  669.         SizeWindow(window, (short)tempFix + kScrollbarWidth + kDIST_FROMLEFT,
  670.             gPrefs.remembWind ? gPrefs.DisasmHeight :
  671.                 ((PRCT_B(window) - PRCT_T(window)) / disasmLineHeight) * disasmLineHeight, false);
  672.         SetupVertScrollBar(window, disasmVScroll);
  673.         SetupDisasmCtlMax(disasmVScroll);
  674.         if (gPrefs.remembWind)
  675.             SetCtlValue(disasmVScroll, gPrefs.DisasmScrollVal);
  676.  
  677.         InitFabWindow(window);
  678.         SetActivate(window, Activate_Disasm);
  679.         SetUpdate(window, Update_Disasm);
  680.         SetDrag(window, nil);
  681.         SetGrow(window, Grow_Disasm);
  682.         SetZoom(window, nil);
  683.         SetGoAway(window, CloseDisasm);
  684.         SetContent(window, Do_Disasm);
  685.  
  686.         InstallRgnHandler((FabWindowPtr)window, NewRgn(), RecalcDump, nil,
  687.                 toMenu(kBalloons_Dump, kBDisasm_Contents), 0);
  688.  
  689.         ResizeObjects((FabWindowPtr)window);
  690.         RecalcGlobalCoords((FabWindowPtr)window);
  691.  
  692.         err = noErr;
  693.         }
  694.     }
  695. return err;
  696. }
  697.  
  698. /* InitPrefs: loads preferences if present */
  699.  
  700. Boolean InitPrefs(void)
  701. {
  702. ParamBlockRec    myPB;
  703. EventRecord    dummyEv;
  704. FSSpec    myFSS;
  705. register Handle    myStrHand, prefsBuffer;
  706. short    prefsFRefNum;
  707. Boolean    targetFolder, isAnAlias;
  708. register OSErr    err;
  709. register SignedByte    oldState;
  710. register Boolean    prefsFileAbsent = false;
  711.  
  712. oldState = WantThisHandleSafe(myStrHand = (Handle)GetString(kSTR_PREFSFILENAME));
  713. if ((err = FindFolder(kOnSystemDisk, kPreferencesFolderType, kCreateFolder,
  714.             &myFSS.vRefNum, &myFSS.parID)) == noErr) {
  715.     err = FSMakeFSSpec(myFSS.vRefNum, myFSS.parID, (ConstStr255Param)*myStrHand, &myFSS);
  716.     if (err == fnfErr)
  717.         prefsFileAbsent = true;
  718.     else if (err == noErr)
  719.         if ((err = ResolveAliasFile(&myFSS, true, &targetFolder, &isAnAlias)) == noErr)
  720.             if (targetFolder)
  721.                 err = paramErr;
  722.             else
  723.                 if ((err = FSpOpenDF(&myFSS, fsRdPerm, &prefsFRefNum)) == noErr) {
  724.                     if (prefsBuffer = NewHandleGeneral(sizeof(struct myprefs))) {
  725.                         myPB.ioParam.ioCompletion = nil;
  726.                         myPB.ioParam.ioRefNum = prefsFRefNum;
  727.                         HLock(prefsBuffer);
  728.                         myPB.ioParam.ioBuffer = *prefsBuffer;
  729.                         myPB.ioParam.ioReqCount = sizeof(struct myprefs);
  730.                         myPB.ioParam.ioPosMode = fsFromStart;
  731.                         myPB.ioParam.ioPosOffset = 0L;
  732.                         (void)PBReadAsync(&myPB);
  733.                         while (myPB.ioParam.ioResult > 0) {
  734.                             SystemTask();
  735.                             (void)EventAvail(everyEvent, &dummyEv);
  736.                             }
  737.                         if ((err = myPB.ioParam.ioResult) == noErr)
  738.                             if (((struct myprefs *)*prefsBuffer)->prefsVersion == kCurPrefsVersion)
  739.                                 gPrefs = *(struct myprefs *)*prefsBuffer;
  740.                         DisposHandle(prefsBuffer);
  741.                         }
  742.                     (void)FSClose(prefsFRefNum);
  743.                     }
  744.     }
  745. HSetState(myStrHand, oldState);
  746.  
  747. return prefsFileAbsent;
  748. }
  749.  
  750. /* GetFontNumber: gets font number from font name */
  751.  
  752. static Boolean    GetFontNumber(ConstStr255Param fontName, short *fontNum)
  753. {
  754. Str255    systemFontName;
  755. register Boolean    retFlag;
  756.  
  757. GetFNum(fontName, fontNum);
  758. if ((retFlag = (*fontNum != 0)) == false) {
  759.     GetFontName(0, systemFontName);
  760.     retFlag = EqualString(fontName, systemFontName, false, false);
  761.     }
  762. return retFlag;
  763. }
  764.  
  765. /* MakeList: builds a list given a rectangle, the window, and
  766. the initial number of lines */
  767.  
  768. static ListHandle MakeList(RectPtr theListRect, WindowPtr theWindow, short lines)
  769. {
  770. Rect    dataBounds;
  771. Rect    tempRect;
  772. Point    cSize = { 0, 0 };
  773. register ListHandle    theList;
  774.  
  775. tempRect = *theListRect;
  776. tempRect.right -= kScrollbarAdjust;
  777. SetRect(&dataBounds, 0, 0, 1, lines);
  778. theList = LNew(&tempRect, &dataBounds, cSize, 0, theWindow, true, false, false, true);
  779. (*theList)->selFlags = lOnlyOne;
  780. LSetSelect(true, cSize, theList);
  781. LDoDraw(true, theList);
  782. return theList;
  783. }
  784.  
  785. /* MakeTE: builds a TextEdit field, given the rectangle,
  786. in the current window */
  787.  
  788. static TEHandle MakeTE(RectPtr Position)
  789. {
  790. Rect    tempRect;
  791.  
  792. tempRect = *Position;
  793. FrameRect(Position);
  794. InsetRect(&tempRect, 3, 3);
  795. return(TENew(&tempRect, &tempRect));
  796. }
  797.  
  798. /* InitIO: initializes the input/output window */
  799.  
  800. static OSErr InitIO(void)
  801. {
  802. enum {
  803. rVScroll = 142,        /* vertical scrollbar control */
  804. rHScroll            /* horizontal scrollbar control */
  805. };
  806.  
  807. Rect    destRect, viewRect;
  808. register WindowPtr    window;
  809. register DocumentPeek doc;
  810. register OSErr    err = appMemFullErr;
  811.  
  812. gWPtr_IO = window = GetNewWindow(kWIND_IO, NewPtrClear(sizeof(DocumentRecord)), (WindowPtr)-1L);
  813. if (window) {
  814.     SetPort(window);
  815.     if (gPrefs.remembWind) {
  816.         if (PtInRgn(topLeft(gPrefs.IOUserState), GetGrayRgn())) {
  817.             (*(WStateDataHandle)((WindowPeek)window)->dataHandle)->userState = gPrefs.IOUserState;
  818.             ZoomWindow(window, inZoomIn, false);
  819.             }
  820.         }
  821.     doc = (DocumentPeek)window;
  822.     GetTERect(window, &viewRect);
  823.     destRect = viewRect;
  824.     destRect.right = destRect.left +
  825.                         (qd.screenBits.bounds.right - qd.screenBits.bounds.left);
  826.     if ( doc->docTE = TENew(&destRect, &viewRect) ) {
  827.         (void)TEFeatureFlag(teFOutlineHilite, TEBitSet, doc->docTE);
  828.         TEAutoView(true, doc->docTE);
  829.         if (doc->docVScroll = GetNewControl(rVScroll, window)) {
  830.             if (doc->docHScroll = GetNewControl(rHScroll, window)) {
  831.     /* adjust & draw the controls, draw the window */
  832.                 AdjustScrollbars(window, true);
  833.  
  834.                 InitFabWindow(window);
  835.                 SetActivate(window, DoActivateWindow);
  836.                 SetUpdate(window, DoUpdateWindow);
  837.                 SetDrag(window, nil);
  838.                 SetGrow(window, DoGrowWindow);
  839.                 SetZoom(window, DoZoomWindow);
  840.                 SetGoAway(window, CloseIO);
  841.                 SetContent(window, DoContentClick);
  842.                 
  843.                 InstallRgnHandler((FabWindowPtr)window, NewRgn(), RecalcIO, gIBeamHandle,
  844.                         toMenu(kBalloons_Dump, kBIO_Contents), 0);
  845.                 ResizeObjects((FabWindowPtr)window);
  846.                 RecalcGlobalCoords((FabWindowPtr)window);
  847.  
  848. //                InstallTrackingHandler(MyTrackingHandler, window, (void *) window);
  849. //                InstallReceiveHandler(MyReceiveDropHandler, window, (void *) window);
  850.                 err = noErr;
  851.                 }
  852.             }
  853.         }
  854.     }
  855. return err;
  856. } /* InitIO */
  857.  
  858. /* InitDump: initializes the Dump window */
  859.  
  860. static OSErr InitDump(void)
  861. {
  862. enum {
  863. krdmpVScroll = 144,    /* vertical scrollbar control */
  864. kCharsInOneLine = 0x002D0000
  865. };
  866.  
  867. FMetricRec    theMetrics;
  868. register Fixed    tempFix;
  869. register WindowPtr    window;
  870. register OSErr    err = appMemFullErr;
  871.  
  872. gWPtr_Dump = window = GetNewWindow(kWIND_Dump, NewPtrClear(sizeof(FabWindowRecord)), (WindowPtr)-1L);
  873. if (window) {
  874.     SetPort(window);
  875.     if (gPrefs.remembWind)
  876.         if (PtInRgn(gPrefs.DumpTopLeft, GetGrayRgn()))
  877.             MoveWindow(window, gPrefs.DumpTopLeft.h, gPrefs.DumpTopLeft.v, false);
  878.     if (dumpVScroll = GetNewControl(krdmpVScroll, window)) {
  879.         TextFont(monaco);
  880.         TextSize(9);
  881.         TextMode(srcCopy);
  882.         FontMetrics(&theMetrics);
  883.         tempFix = theMetrics.descent + theMetrics.ascent + theMetrics.leading;
  884.         tempFix = mySwap(tempFix);
  885.         dumpLineHeight = (short)tempFix;
  886.         dumpFromTop = *(short *)&theMetrics.ascent;
  887.         dumpCWidMax = *(short *)&theMetrics.widMax;
  888.         tempFix = FixMul(theMetrics.widMax, kCharsInOneLine);
  889.         tempFix = mySwap(tempFix);
  890.         SizeWindow(window, (short)tempFix + kScrollbarWidth + kDIST_FROMLEFT,
  891.             gPrefs.remembWind ? gPrefs.DumpHeight :
  892.                 ((PRCT_B(window) - PRCT_T(window)) / dumpLineHeight) * dumpLineHeight,
  893.             false);
  894.         SetupVertScrollBar(window, dumpVScroll);
  895.         SetupDumpCtlMax(dumpVScroll);
  896.         if (gPrefs.remembWind)
  897.             SetCtlValue(dumpVScroll, gPrefs.DumpScrollVal);
  898.  
  899.         InitFabWindow(window);
  900.         SetActivate(window, Activate_Dump);
  901.         SetUpdate(window, Update_Dump);
  902.         SetDrag(window, nil);
  903.         SetGrow(window, Grow_Dump);
  904.         SetZoom(window, nil);
  905.         SetGoAway(window, CloseDump);
  906.         SetContent(window, Do_Dump);
  907.  
  908.         InstallRgnHandler((FabWindowPtr)window, NewRgn(), RecalcDump, nil,
  909.                 toMenu(kBalloons_Dump, kBDump_Contents), 0);
  910.  
  911.         ResizeObjects((FabWindowPtr)window);
  912.         RecalcGlobalCoords((FabWindowPtr)window);
  913.  
  914.         err = noErr;
  915.         }
  916.     }
  917. return err;
  918. } /* InitDump */
  919.  
  920. /* FatalErrorAlert: errors while initing windows */
  921.  
  922. static void FatalErrorAlert(short alertID, OSErr reason)
  923. {
  924. Str255    tempS;
  925.  
  926. MyNumToString(reason, tempS);
  927. ParamText(tempS, nil, nil, nil);
  928. InitCursor();
  929. (void)StopAlert(alertID, nil);
  930. }
  931.  
  932. #endif
  933.  
  934.